// 引入登录验证工具
const authUtil = require('../../utils/auth')

Page({
  data: {
    // 当前选择的服务信息
    selectedService: null,
    
    // 表单数据
    formData: {
      customerName: '',
      phone: '',
      company: '',
      serviceId: null,        // 关联的服务ID（外键）
      serviceType: '',
      serviceProject: '',
      description: '',
      preferredDate: '',
      preferredTime: '',
      address: '',
      urgency: 'normal'
    },
    
    // 服务类型选项
    serviceTypes: [
      { value: 'sme_market', label: '中小市场', icon: '🏢' },
      { value: 'info_integration', label: '信息化集成', icon: '💻' },
      { value: 'engineering', label: '工程施工', icon: '🏗️' },
      { value: 'network_maintenance', label: '网络维护', icon: '🔧' },
      { value: 'smart_home', label: '智能家居', icon: '🏠' },
      { value: 'measurement', label: '计量检测', icon: '📏' },
      { value: 'materials', label: '材料设备', icon: '📦' },
      { value: 'construction_team', label: '施工队伍', icon: '👷' },
      { value: 'qualification', label: '企业资质', icon: '📋' },
      { value: 'case_sharing', label: '案例分享', icon: '📚' }
    ],
    
    // 紧急程度选项
    urgencyLevels: [
      { value: 'low', label: '不紧急', color: '#52c41a', desc: '1-2周内处理' },
      { value: 'normal', label: '一般', color: '#1890ff', desc: '3-7天内处理' },
      { value: 'high', label: '紧急', color: '#fa8c16', desc: '1-3天内处理' },
      { value: 'urgent', label: '非常紧急', color: '#f5222d', desc: '24小时内响应' }
    ],
    
    // 时间段选项
    timeSlots: [
      { value: '09:00-10:00', label: '09:00-10:00', period: '上午' },
      { value: '10:00-11:00', label: '10:00-11:00', period: '上午' },
      { value: '11:00-12:00', label: '11:00-12:00', period: '上午' },
      { value: '14:00-15:00', label: '14:00-15:00', period: '下午' },
      { value: '15:00-16:00', label: '15:00-16:00', period: '下午' },
      { value: '16:00-17:00', label: '16:00-17:00', period: '下午' }
    ],
    
    // 选择器状态
    selectedServiceTypeLabel: '',
    selectedUrgencyLabel: '一般',
    selectedUrgencyDesc: '3-7天内处理',
    selectedTimeSlot: '',
    minDate: '',
    maxDate: '',
    
    // 页面状态
    isSubmitting: false,
    userInfo: null,
    step: 1, // 当前步骤：1-服务信息，2-联系信息，3-预约时间，4-确认提交
    showServiceSelector: false,
    sessionExpiredTipShown: false // 是否已显示过session过期提示
  },

  async onLoad(options) {
    console.log('📅 预约页面加载，参数:', options)
    
    // 首先检查登录状态
    const loginCheck = await this.checkLoginStatus()
    if (!loginCheck.success) {
      console.log('❌ 用户未登录，阻止访问预约页面')
      this.showLoginRequired()
      return
    }
    
    console.log('✅ 用户已登录，允许访问预约页面')
    
    // 设置日期范围
    const today = new Date()
    const minDate = today.toISOString().split('T')[0]
    
    // 最大日期为30天后
    const maxDate = new Date()
    maxDate.setDate(maxDate.getDate() + 30)
    const maxDateStr = maxDate.toISOString().split('T')[0]

    // 设置默认日期为明天
    const tomorrow = new Date()
    tomorrow.setDate(tomorrow.getDate() + 1)
    const dateStr = tomorrow.toISOString().split('T')[0]

    this.setData({
      minDate: minDate,
      maxDate: maxDateStr,
      'formData.preferredDate': dateStr
    })

    // 首先尝试恢复之前保存的预约状态
    const restored = this.restoreBookingState()
    
    if (!restored) {
      // 如果没有恢复状态，则处理传入的服务信息
      console.log('🔍 URL参数详细分析:')
      console.log('  - serviceType:', options.serviceType)
      console.log('  - service:', options.service)
      console.log('  - productId:', options.productId)
      console.log('  - 其他参数:', Object.keys(options).filter(key => !['serviceType', 'service', 'productId'].includes(key)))
      
      this.handleServiceInfo(options)
    } else {
      console.log('🔄 已恢复预约状态，跳过URL参数处理')
    }
    
    // 获取用户信息
    this.getUserInfo()

    // 获取历史订单信息，自动填充联系方式
    this.loadHistoryContactInfo()

    // 测试位置API可用性
    this.testLocationAPI()
  },

  async onShow() {
    // 重新检查登录状态（宽松模式）
    const loginCheck = await this.checkLoginStatus()
    if (!loginCheck.success) {
      console.log('❌ 页面显示时发现用户未登录')
      this.showLoginRequired()
      return
    }

    // 只在真正需要时显示session过期提示
    // 注意：如果云端验证成功，说明用户登录有效，不应显示过期提示
    if (loginCheck.sessionExpired && !loginCheck.cloudValidationSuccess && this.shouldShowSessionExpiredTip()) {
      console.log('⚠️ 微信session已过期且云端验证失败，显示友好提示')
      wx.showToast({
        title: '登录状态已过期，建议重新登录',
        icon: 'none',
        duration: 2000
      })
      
      // 记录已显示过提示，避免重复显示
      this.setData({ sessionExpiredTipShown: true })
      
      // 记录显示时间，避免短时间内重复显示
      wx.setStorageSync('lastSessionTipTime', Date.now())
    }

    // 如果关键联系信息为空，尝试重新获取历史信息
    if (!this.data.formData.phone || !this.data.formData.address) {
      this.loadHistoryContactInfo()
    }
  },

  // 判断是否应该显示session过期提示
  shouldShowSessionExpiredTip() {
    // 如果已经显示过提示，不再显示
    if (this.data.sessionExpiredTipShown) {
      console.log('🔄 已显示过session过期提示，跳过')
      return false
    }
    
    // 检查用户最近登录时间，如果是最近登录的，不显示提示
    const userInfo = wx.getStorageSync('userInfo')
    if (userInfo && userInfo.lastLoginTime) {
      const lastLoginTime = new Date(userInfo.lastLoginTime).getTime()
      const now = Date.now()
      const fiveMinutes = 5 * 60 * 1000
      
      if (now - lastLoginTime < fiveMinutes) {
        console.log('🔄 用户最近5分钟内登录过，跳过session过期提示')
        return false
      }
    }
    
    // 如果是从登录页面返回的，不显示提示
    const pages = getCurrentPages()
    if (pages.length > 1) {
      const prevPage = pages[pages.length - 2]
      if (prevPage && prevPage.route === 'pages/profile/profile') {
        console.log('🔄 从个人中心返回，跳过session过期提示')
        return false
      }
    }
    
    // 如果有待恢复的预约状态，说明是登录后返回，不显示提示
    const pendingState = wx.getStorageSync('pendingBookingState')
    if (pendingState) {
      console.log('🔄 检测到待恢复状态，跳过session过期提示')
      return false
    }
    
    // 检查是否是同一会话内的重复访问
    const lastTipTime = wx.getStorageSync('lastSessionTipTime')
    if (lastTipTime) {
      const now = Date.now()
      const tenMinutes = 10 * 60 * 1000
      
      if (now - lastTipTime < tenMinutes) {
        console.log('🔄 10分钟内已显示过提示，跳过')
        return false
      }
    }
    
    console.log('✅ 满足显示session过期提示的条件')
    return true
  },

  // 处理传入的服务信息
  handleServiceInfo(options) {
    console.log('🔄 开始处理服务信息')
    console.log('📥 接收到的options:', options)

    const { serviceType, service } = options
    let selectedService = null
    let selectedServiceTypeLabel = ''

    console.log('🔍 参数解析结果:')
    console.log('  - serviceType:', serviceType)
    console.log('  - service:', service)
    console.log('  - service存在:', !!service)
    console.log('  - serviceType存在:', !!serviceType)

    // 如果传入了具体的服务信息（从服务分类页面过来）
    if (service) {
      console.log('✅ 进入service参数处理分支')
      console.log('📝 原始service参数:', service)

      try {
        console.log('🔄 开始解析service参数...')
        selectedService = JSON.parse(decodeURIComponent(service))
        console.log('📦 解析后的服务信息:', selectedService)
        console.log('🔍 服务信息字段检查:')
        console.log('  - _id:', selectedService._id)
        console.log('  - id:', selectedService.id)
        console.log('  - serviceId:', selectedService.serviceId)
        console.log('  - title:', selectedService.title)
        console.log('  - serviceTitle:', selectedService.serviceTitle)
        
        const selectedType = this.data.serviceTypes.find(type => type.value === selectedService.serviceType)
        if (selectedType) {
          selectedServiceTypeLabel = selectedType.label
        }
        
        // 根据服务信息智能预填描述
        const smartDescription = this.generateSmartDescription(selectedService)
        
        // 确保serviceId正确设置 - 必须使用_id字段（数据库主键）
        const serviceId = selectedService._id || null

        // 如果没有_id字段，记录警告
        if (!selectedService._id) {
          console.warn('⚠️ 服务数据缺少_id字段，这将导致关联失败')
          console.warn('服务数据:', selectedService)
        }

        this.setData({
          selectedService: selectedService,
          'formData.serviceId': serviceId,
          'formData.serviceType': selectedService.serviceType || selectedService.category,
          'formData.serviceProject': selectedService.serviceTitle || selectedService.title || '',
          'formData.description': smartDescription,
          selectedServiceTypeLabel: selectedServiceTypeLabel
        })

        // 调试信息：检查服务ID设置
        console.log('🔗 设置服务ID:', serviceId)
        console.log('📋 选择的服务:', selectedService)
        console.log('🔍 serviceId字段检查:')
        console.log('  - selectedService._id:', selectedService._id)
        console.log('  - selectedService.id:', selectedService.id)
        console.log('  - 最终使用的serviceId（必须是_id）:', serviceId)

        // 验证serviceId是否为有效的MongoDB ObjectId格式
        if (serviceId && typeof serviceId === 'string' && serviceId.length === 24) {
          console.log('✅ serviceId格式验证通过（24位MongoDB ObjectId）')
        } else if (serviceId) {
          console.warn('⚠️ serviceId格式不是标准的MongoDB ObjectId:', serviceId)
        } else {
          console.error('❌ serviceId为空，订单将无法关联到服务')
        }
      } catch (error) {
        console.error('解析服务信息失败:', error)
      }
    }
    // 如果只传入了服务类型（从首页等其他地方过来）
    else if (serviceType) {
      console.log('⚠️ 进入serviceType分支（没有完整服务信息）')
      console.log('📝 serviceType:', serviceType)

      const selectedType = this.data.serviceTypes.find(type => type.value === serviceType)
      if (selectedType) {
        selectedServiceTypeLabel = selectedType.label
        console.log('✅ 找到服务类型:', selectedServiceTypeLabel)
        this.setData({
          'formData.serviceType': serviceType,
          'formData.serviceId': null,  // 明确设置为null
          selectedServiceTypeLabel: selectedServiceTypeLabel
        })
        console.log('⚠️ serviceId设置为null（因为只有serviceType）')
      } else {
        console.log('❌ 未找到匹配的服务类型')
      }
    } else {
      console.log('❌ 既没有service参数，也没有serviceType参数')
    }

    // 最终状态调试
    console.log('🏁 handleServiceInfo处理完成')
    console.log('📊 最终状态:')
    console.log('  - selectedService:', selectedService)
    console.log('  - selectedServiceTypeLabel:', selectedServiceTypeLabel)
    console.log('  - formData.serviceId将设置为:', selectedService ? (selectedService.serviceId || selectedService._id || selectedService.id || null) : null)
  },

  // 获取历史订单联系信息
  async loadHistoryContactInfo() {
    try {
      console.log('📞 开始获取历史联系信息...')

      // 检查用户登录状态
      const userInfo = wx.getStorageSync('userInfo')
      if (!userInfo || !userInfo.openid) {
        console.log('⚠️ 用户未登录，跳过历史信息获取')
        return
      }

      // 先尝试从本地存储获取
      const localOrders = wx.getStorageSync('orders') || []
      if (localOrders.length > 0) {
        // 按创建时间排序，获取最新的订单
        const sortedOrders = localOrders.sort((a, b) => {
          const timeA = new Date(a.createTime || a.createDate || 0).getTime()
          const timeB = new Date(b.createTime || b.createDate || 0).getTime()
          return timeB - timeA
        })

        const latestOrder = sortedOrders[0]
        if (latestOrder.phone || latestOrder.address || latestOrder.company) {
          console.log('📱 从本地存储获取到历史信息:')
          if (latestOrder.phone) {
            console.log('  - 手机号:', latestOrder.phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2'))
          }
          if (latestOrder.company) {
            console.log('  - 公司:', latestOrder.company)
          }
          if (latestOrder.address) {
            console.log('  - 地址:', latestOrder.address.length > 20 ? latestOrder.address.substring(0, 20) + '...' : latestOrder.address)
          }
          this.setContactInfo(latestOrder)
          return
        }
      }

      // 如果本地没有，从云端获取最近的订单
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'getUserOrders',
          data: {
            page: 0,
            limit: 1  // 只获取最新的一条订单
          }
        }
      })

      if (result.result && result.result.success && result.result.data.length > 0) {
        const latestOrder = result.result.data[0]
        console.log('☁️ 从云端获取到历史联系信息')
        this.setContactInfo(latestOrder)
      } else {
        console.log('📝 没有找到历史订单，使用默认信息')
      }

    } catch (error) {
      console.error('❌ 获取历史联系信息失败:', error)
      // 失败不影响正常使用，继续使用默认值
    }
  },

  // 设置联系信息
  setContactInfo(orderData) {
    const updates = {}

    // 自动填充手机号码（如果当前为空）
    if (orderData.phone && !this.data.formData.phone) {
      updates['formData.phone'] = orderData.phone
      console.log('📱 自动填充手机号码')
    }

    // 自动填充公司名称（如果当前为空且历史订单有）
    if (orderData.company && !this.data.formData.company) {
      updates['formData.company'] = orderData.company
      console.log('🏢 自动填充公司名称')
    }

    // 自动填充服务地址（如果当前为空且历史订单有）
    if (orderData.address && !this.data.formData.address) {
      updates['formData.address'] = orderData.address
      console.log('📍 自动填充服务地址')
    }

    // 如果有更新，则应用到页面
    if (Object.keys(updates).length > 0) {
      this.setData(updates)

      // 生成详细的提示信息
      const updateTypes = []
      if (updates['formData.phone']) updateTypes.push('联系方式')
      if (updates['formData.company']) updateTypes.push('公司信息')
      if (updates['formData.address']) updateTypes.push('服务地址')

      const message = updateTypes.length === 1
        ? `已自动填充${updateTypes[0]}`
        : `已自动填充${updateTypes.join('、')}`

      wx.showToast({
        title: message,
        icon: 'success',
        duration: 2500
      })

      console.log(`✅ 成功自动填充: ${updateTypes.join('、')}`)
    } else {
      console.log('📝 没有需要填充的信息')
    }
  },

  // 显示历史地址选择器
  showHistoryAddresses() {
    try {
      const localOrders = wx.getStorageSync('orders') || []

      // 提取所有不重复的地址
      const addresses = [...new Set(
        localOrders
          .filter(order => order.address && order.address.trim())
          .map(order => order.address.trim())
      )]

      if (addresses.length === 0) {
        wx.showToast({
          title: '暂无历史地址',
          icon: 'none'
        })
        return
      }

      // 限制显示最近的5个地址
      const recentAddresses = addresses.slice(0, 5)

      wx.showActionSheet({
        itemList: recentAddresses,
        success: (res) => {
          const selectedAddress = recentAddresses[res.tapIndex]
          this.setData({
            'formData.address': selectedAddress
          })

          wx.showToast({
            title: '地址已选择',
            icon: 'success'
          })
        }
      })

    } catch (error) {
      console.error('显示历史地址失败:', error)
      wx.showToast({
        title: '获取历史地址失败',
        icon: 'none'
      })
    }
  },

  // 生成智能描述
  generateSmartDescription(service) {
    let description = `【选择的服务】\n服务项目：${service.serviceTitle}\n`
    
    if (service.servicePrice && service.servicePrice !== '0' && service.servicePrice !== 'face') {
      description += `参考价格：¥${service.servicePrice}${service.serviceUnit || ''}\n`
    } else if (service.servicePrice === '0' || service.servicePrice === 'face') {
      description += `价格：面议\n`
    }
    
    description += `\n【请详细描述您的需求】\n`
    
    // 根据服务类型提供引导问题
    const guidanceMap = {
      'sme_market': '• 您的企业规模和行业？\n• 希望解决什么市场问题？\n• 预期的项目周期？',
      'info_integration': '• 现有的系统架构情况？\n• 需要集成哪些系统？\n• 用户规模大概多少？',
      'engineering': '• 项目的具体位置和规模？\n• 工程类型和技术要求？\n• 预计的工期要求？',
      'network_maintenance': '• 网络设备的类型和数量？\n• 现有网络架构情况？\n• 维护频率要求？',
      'smart_home': '• 房屋面积和户型？\n• 需要哪些智能功能？\n• 预算范围？',
      'measurement': '• 需要检测的设备类型？\n• 检测项目和标准要求？\n• 是否需要出具证书？',
      'materials': '• 需要的材料类型和规格？\n• 项目规模和用量？\n• 交货时间要求？',
      'construction_team': '• 工程类型和规模？\n• 技术难度和特殊要求？\n• 工期安排？',
      'qualification': '• 需要办理的资质类型？\n• 企业基本情况？\n• 办理时间要求？',
      'case_sharing': '• 希望了解哪个行业的案例？\n• 项目规模和类型？\n• 特别关注的技术点？'
    }
    
    const guidance = guidanceMap[service.serviceType] || '• 请详细说明您的具体需求\n• 项目的时间安排\n• 特殊要求或注意事项'
    description += guidance
    
    return description
  },

  // 获取用户信息
  async getUserInfo() {
    try {
      const result = await wx.cloud.callFunction({
        name: 'userManager',
        data: {
          action: 'getUserInfo'
        }
      })

      if (result.result.success) {
        const userInfo = result.result.userInfo
        this.setData({
          userInfo: userInfo,
          'formData.customerName': userInfo.nickName || ''
        })
      }
    } catch (error) {
      console.error('获取用户信息失败:', error)
    }
  },

  // 切换服务选择器
  toggleServiceSelector() {
    this.setData({
      showServiceSelector: !this.data.showServiceSelector
    })
  },

  // 选择服务类型
  selectServiceType(e) {
    const { type } = e.currentTarget.dataset
    const selectedType = this.data.serviceTypes.find(t => t.value === type.value)
    
    this.setData({
      'formData.serviceId': null,  // 清除服务ID
      'formData.serviceType': type.value,
      'formData.serviceProject': '', // 清除服务项目
      selectedServiceTypeLabel: type.label,
      showServiceSelector: false,
      selectedService: null // 清除原有的具体服务信息
    })
    
    // 如果切换了服务类型，清空描述让用户重新填写
    if (!this.data.selectedService) {
      this.setData({
        'formData.description': ''
      })
    }
  },

  // 输入框变化处理
  onInputChange(e) {
    const { field } = e.currentTarget.dataset
    const { value } = e.detail
    
    this.setData({
      [`formData.${field}`]: value
    })
  },

  // 选择器变化处理
  onPickerChange(e) {
    const { field } = e.currentTarget.dataset
    const { value } = e.detail

    if (field === 'urgency') {
      const selectedUrgency = this.data.urgencyLevels[value]
      this.setData({
        [`formData.${field}`]: selectedUrgency.value,
        selectedUrgencyLabel: selectedUrgency.label,
        selectedUrgencyDesc: selectedUrgency.desc
      })
    } else if (field === 'preferredTime') {
      const selectedTime = this.data.timeSlots[value]
      this.setData({
        [`formData.${field}`]: selectedTime.value,
        selectedTimeSlot: selectedTime.label
      })
    } else {
      this.setData({
        [`formData.${field}`]: value
      })
    }
  },

  // 测试位置API是否可用
  testLocationAPI() {
    console.log('🔧 测试位置API可用性...')
    
    // 检查API是否存在
    if (typeof wx.chooseLocation !== 'function') {
      console.error('❌ wx.chooseLocation API 不可用')
      wx.showModal({
        title: '功能不可用',
        content: '当前环境不支持位置选择功能，请在真机上测试',
        showCancel: false
      })
      return false
    }
    
    // 检查基础库版本
    const systemInfo = wx.getSystemInfoSync()
    console.log('📱 系统信息:', systemInfo)
    
    return true
  },

  // 选择地址
  chooseLocation() {
    console.log('📍 用户点击选择位置按钮')
    
    // 首先检查位置权限
    wx.getSetting({
      success: (settingRes) => {
        console.log('🔧 当前权限设置:', settingRes.authSetting)
        
        if (settingRes.authSetting['scope.userLocation'] === false) {
          // 用户之前拒绝了位置权限
          console.log('❌ 用户之前拒绝了位置权限')
          wx.showModal({
            title: '需要位置权限',
            content: '检测到您之前拒绝了位置权限，请前往设置中手动开启位置权限，然后重试',
            showCancel: true,
            cancelText: '稍后开启',
            confirmText: '去设置',
            success: (modalRes) => {
              if (modalRes.confirm) {
                wx.openSetting({
                  success: (openRes) => {
                    console.log('📱 权限设置结果:', openRes.authSetting)
                    if (openRes.authSetting['scope.userLocation']) {
                      // 权限开启后重新调用
                      this.performChooseLocation()
                    }
                  }
                })
              }
            }
          })
          return
        }
        
        // 直接调用位置选择
        this.performChooseLocation()
      },
      fail: (err) => {
        console.error('❌ 获取设置失败:', err)
        // 即使获取设置失败，也尝试调用位置选择
        this.performChooseLocation()
      }
    })
  },

  // 执行位置选择
  performChooseLocation() {
    console.log('📍 执行位置选择...')
    
    wx.chooseLocation({
      success: (res) => {
        console.log('✅ 位置选择成功:', res)
        const fullAddress = res.address + (res.name ? ' ' + res.name : '')
        this.setData({
          'formData.address': fullAddress
        })
        
        wx.showToast({
          title: '位置已选择',
          icon: 'success',
          duration: 1500
        })
      },
      fail: (err) => {
        console.error('❌ 位置选择失败:', err)
        
        if (err.errMsg.indexOf('auth deny') !== -1 || err.errMsg.indexOf('authorize deny') !== -1) {
          // 权限被拒绝
          wx.showModal({
            title: '需要位置权限',
            content: '请在设置中开启位置权限以选择地址，或者您可以手动输入地址',
            showCancel: true,
            cancelText: '手动输入',
            confirmText: '去设置',
            success: (modalRes) => {
              if (modalRes.confirm) {
                wx.openSetting()
              }
            }
          })
        } else if (err.errMsg.indexOf('cancel') !== -1) {
          // 用户取消选择
          console.log('👤 用户取消了位置选择')
        } else {
          // 其他错误
          wx.showModal({
            title: '位置选择失败',
            content: `选择位置时发生错误：${err.errMsg}。您可以手动输入地址。`,
            showCancel: false,
            confirmText: '确定'
          })
        }
      }
    })
  },

  // 下一步
  nextStep() {
    const { step } = this.data
    
    if (step === 1) {
      // 验证服务信息
      if (!this.data.formData.serviceType) {
        wx.showToast({ title: '请选择服务类型', icon: 'none' })
        return
      }
      if (!this.data.formData.description.trim()) {
        wx.showToast({ title: '请描述服务需求', icon: 'none' })
        return
      }
    } else if (step === 2) {
      // 验证联系信息
      if (!this.data.formData.customerName.trim()) {
        wx.showToast({ title: '请输入联系人姓名', icon: 'none' })
        return
      }
      if (!this.data.formData.phone.trim()) {
        wx.showToast({ title: '请输入联系电话', icon: 'none' })
        return
      }
      const phoneRegex = /^1[3-9]\d{9}$/
      if (!phoneRegex.test(this.data.formData.phone)) {
        wx.showToast({ title: '请输入正确的手机号', icon: 'none' })
        return
      }
    } else if (step === 3) {
      // 验证预约时间
      if (!this.data.formData.preferredDate) {
        wx.showToast({ title: '请选择预约日期', icon: 'none' })
        return
      }
      const selectedDate = new Date(this.data.formData.preferredDate)
      const today = new Date()
      today.setHours(0, 0, 0, 0)
      if (selectedDate < today) {
        wx.showToast({ title: '预约日期不能早于今天', icon: 'none' })
        return
      }
    }
    
    if (step < 4) {
      this.setData({ step: step + 1 })
    }
  },

  // 上一步
  prevStep() {
    const { step } = this.data
    if (step > 1) {
      this.setData({ step: step - 1 })
    }
  },

  // 表单验证
  validateForm() {
    const { formData } = this.data
    
    if (!formData.customerName.trim()) {
      wx.showToast({ title: '请输入联系人姓名', icon: 'none' })
      return false
    }
    
    if (!formData.phone.trim()) {
      wx.showToast({ title: '请输入联系电话', icon: 'none' })
      return false
    }
    
    const phoneRegex = /^1[3-9]\d{9}$/
    if (!phoneRegex.test(formData.phone)) {
      wx.showToast({ title: '请输入正确的手机号', icon: 'none' })
      return false
    }
    
    if (!formData.serviceType) {
      wx.showToast({ title: '请选择服务类型', icon: 'none' })
      return false
    }
    
    if (!formData.description.trim()) {
      wx.showToast({ title: '请描述服务需求', icon: 'none' })
      return false
    }
    
    if (!formData.preferredDate) {
      wx.showToast({ title: '请选择预约日期', icon: 'none' })
      return false
    }

    const selectedDate = new Date(formData.preferredDate)
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    
    if (selectedDate < today) {
      wx.showToast({ title: '预约日期不能早于今天', icon: 'none' })
      return false
    }
    
    return true
  },

  // 提交预约
  async submitBooking() {
    if (!this.validateForm() || this.data.isSubmitting) {
      return
    }

    // 提交前再次验证登录状态
    const loginCheck = await this.checkLoginStatus()
    if (!loginCheck.success) {
      console.log('❌ 提交预约时发现用户未登录')
      this.showLoginRequired()
      return
    }

    this.setData({ isSubmitting: true })
    wx.showLoading({ title: '提交中...' })

    try {
      // 准备订单数据
      const orderData = {
        ...this.data.formData,
        serviceTypeLabel: this.data.selectedServiceTypeLabel,
        selectedService: this.data.selectedService
      }

      // 调试信息：检查serviceId是否正确传递
      console.log('📋 提交订单数据:', orderData)
      console.log('🔗 serviceId:', orderData.serviceId)
      console.log('🔗 selectedService:', this.data.selectedService)
      console.log('📝 完整formData:', this.data.formData)

      // 详细检查serviceId的来源
      console.log('🔍 serviceId来源分析:')
      console.log('  - formData.serviceId:', this.data.formData.serviceId)
      console.log('  - selectedService存在:', !!this.data.selectedService)
      if (this.data.selectedService) {
        console.log('  - selectedService._id:', this.data.selectedService._id)
        console.log('  - selectedService.id:', this.data.selectedService.id)
        console.log('  - selectedService.serviceId:', this.data.selectedService.serviceId)
      }

      // 验证serviceId的有效性
      if (!orderData.serviceId) {
        console.warn('⚠️ 警告：serviceId为null！这将导致订单无法关联到具体服务')
        console.warn('可能的原因：')
        console.warn('1. 用户通过服务网格进入（只有serviceType）')
        console.warn('2. 服务数据中缺少_id字段')
        console.warn('3. 数据传递过程中丢失了ID信息')
      } else {
        // 验证serviceId格式
        if (typeof orderData.serviceId === 'string' && orderData.serviceId.length === 24) {
          console.log('✅ serviceId格式正确，将关联到services集合的_id字段')
        } else {
          console.warn('⚠️ serviceId格式异常，可能无法正确关联:', orderData.serviceId)
        }
      }

      // 调用云函数创建订单
      const result = await wx.cloud.callFunction({
        name: 'businessManager',
        data: {
          action: 'createOrder',
          data: orderData
        }
      })

      wx.hideLoading()

      if (result.result.success) {
        const orderId = result.result.orderId

        wx.showModal({
          title: '预约成功 🎉',
          content: `您的预约已提交成功！\n订单号：${orderId}\n我们将在24小时内联系您确认服务详情。`,
          showCancel: false,
          confirmText: '查看订单',
          success: () => {
            wx.redirectTo({
              url: `/pages/order-detail/order-detail?id=${orderId}`
            })
          }
        })
      } else {
        wx.showToast({
          title: result.result.error || '提交失败',
          icon: 'none'
        })
      }
    } catch (error) {
      wx.hideLoading()
      console.error('提交预约失败:', error)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      })
    } finally {
      this.setData({ isSubmitting: false })
    }
  },

  // 重置表单
  resetForm() {
    wx.showModal({
      title: '确认重置',
      content: '确定要清空所有填写的内容吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            formData: {
              customerName: this.data.userInfo?.nickName || '',
              phone: '',
              company: '',
              serviceId: null,
              serviceType: '',
              serviceProject: '',
              description: '',
              preferredDate: '',
              preferredTime: '',
              address: '',
              urgency: 'normal'
            },
            selectedServiceTypeLabel: '',
            selectedUrgencyLabel: '一般',
            selectedUrgencyDesc: '3-7天内处理',
            selectedTimeSlot: '',
            selectedService: null,
            step: 1
          })
          wx.showToast({
            title: '表单已重置',
            icon: 'success'
          })
        }
      }
    })
  },

  // 检查登录状态（宽松模式，避免死循环）
  async checkLoginStatus() {
    console.log('🔐 开始检查预约页面登录状态...')
    
    try {
      // 首先检查本地登录状态（不清除数据）
      const isLoggedIn = wx.getStorageSync('isLoggedIn')
      const userInfo = wx.getStorageSync('userInfo')
      
      console.log('📱 本地登录状态:', { isLoggedIn, hasUserInfo: !!userInfo })
      
      if (!isLoggedIn || !userInfo || !userInfo.openid) {
        console.log('❌ 本地登录状态无效')
        return { 
          success: false, 
          reason: 'local_login_invalid', 
          message: '本地登录状态无效，请重新登录' 
        }
      }
      
      // 先尝试云端验证，如果成功就不需要检查session
      try {
        const result = await wx.cloud.callFunction({
          name: 'userManager',
          data: {
            action: 'getUserInfo'
          }
        })

        if (result.result.success) {
          const cloudUserInfo = result.result.userInfo
          console.log('✅ 云端用户信息验证成功，跳过session检查')
          return { 
            success: true, 
            userInfo: cloudUserInfo,
            cloudValidationSuccess: true 
          }
        }
      } catch (cloudError) {
        console.log('⚠️ 云端验证失败，继续检查微信session:', cloudError.message)
      }
      
      // 只有在云端验证失败时才检查微信session
      const sessionValid = await this.checkWechatSessionOnly()
      
      if (!sessionValid) {
        console.log('⚠️ 微信session已过期，但保持本地登录状态')
        // 不清除本地数据，仍然允许访问
        return { 
          success: true, 
          userInfo: userInfo,
          sessionExpired: true 
        }
      }
      
      console.log('✅ 微信session有效')
      return { 
        success: true, 
        userInfo: userInfo 
      }
      
    } catch (error) {
      console.error('❌ 登录状态检查异常:', error)
      return { success: false, reason: 'error', message: '登录检查失败' }
    }
  },

  // 仅检查微信session，不清除本地数据
  checkWechatSessionOnly() {
    return new Promise((resolve) => {
      wx.checkSession({
        success: () => {
          console.log('✅ 微信session有效')
          resolve(true)
        },
        fail: () => {
          console.log('❌ 微信session已过期（但不清除本地数据）')
          resolve(false)
        }
      })
    })
  },

  // 显示登录要求提示
  showLoginRequired() {
    console.log('🔐 显示登录要求提示')
    
    // 保存当前页面的状态和参数，用于登录后返回
    this.saveBookingState()
    
    wx.showModal({
      title: '需要登录 🔐',
      content: '预约服务需要登录后才能使用，请先登录您的账户。',
      confirmText: '立即登录',
      cancelText: '返回',
      success: (res) => {
        if (res.confirm) {
          // 跳转到个人中心登录（使用switchTab因为profile是tabBar页面）
          wx.switchTab({
            url: '/pages/profile/profile'
          })
        } else {
          // 返回上一页
          this.goBack()
        }
      }
    })
  },

  // 返回上一页
  goBack() {
    const pages = getCurrentPages()
    if (pages.length > 1) {
      wx.navigateBack()
    } else {
      // 如果没有上一页，跳转到首页
      wx.switchTab({
        url: '/pages/index/index'
      })
    }
  },

  // 保存预约状态，用于登录后恢复
  saveBookingState() {
    console.log('💾 保存预约状态到本地存储')
    
    const bookingState = {
      // 表单数据
      formData: this.data.formData,
      // 选择的服务信息
      selectedService: this.data.selectedService,
      selectedServiceTypeLabel: this.data.selectedServiceTypeLabel,
      // 当前步骤
      step: this.data.step,
      // 其他状态
      selectedUrgencyLabel: this.data.selectedUrgencyLabel,
      selectedUrgencyDesc: this.data.selectedUrgencyDesc,
      selectedTimeSlot: this.data.selectedTimeSlot,
      // 保存时间戳
      savedAt: Date.now(),
      // 页面来源信息
      fromLogin: true
    }
    
    // 保存到本地存储
    wx.setStorageSync('pendingBookingState', bookingState)
    wx.setStorageSync('loginReturnUrl', '/pages/booking/booking')
    
    console.log('💾 已保存预约状态:', bookingState)
  },

  // 恢复预约状态
  restoreBookingState() {
    console.log('🔄 尝试恢复预约状态')
    
    try {
      const bookingState = wx.getStorageSync('pendingBookingState')
      
      if (!bookingState) {
        console.log('📝 没有找到待恢复的预约状态')
        return false
      }
      
      // 检查保存时间，超过30分钟的状态不恢复
      const savedAt = bookingState.savedAt || 0
      const now = Date.now()
      const thirtyMinutes = 30 * 60 * 1000
      
      if (now - savedAt > thirtyMinutes) {
        console.log('⏰ 预约状态已过期，清除旧状态')
        wx.removeStorageSync('pendingBookingState')
        return false
      }
      
      console.log('✅ 找到有效的预约状态，开始恢复')
      
      // 恢复表单数据
      this.setData({
        formData: bookingState.formData || this.data.formData,
        selectedService: bookingState.selectedService || null,
        selectedServiceTypeLabel: bookingState.selectedServiceTypeLabel || '',
        step: bookingState.step || 1,
        selectedUrgencyLabel: bookingState.selectedUrgencyLabel || '一般',
        selectedUrgencyDesc: bookingState.selectedUrgencyDesc || '3-7天内处理',
        selectedTimeSlot: bookingState.selectedTimeSlot || ''
      })
      
      // 清除已使用的状态
      wx.removeStorageSync('pendingBookingState')
      
      // 显示恢复成功提示
      wx.showToast({
        title: '已恢复预约信息',
        icon: 'success',
        duration: 2000
      })
      
      console.log('🔄 预约状态恢复完成')
      return true
      
    } catch (error) {
      console.error('❌ 恢复预约状态失败:', error)
      wx.removeStorageSync('pendingBookingState')
      return false
    }
  },


})
